#include "etatgraphics.h"

#include "etat.h"
#include "joueur.h"
#include "pion.h"
#include "plateaurisq.h"
#include "frontiere.h"

EtatGraphics::EtatGraphics(Etat *etat) :
    QObject(),
    QGraphicsItem()
{
    //setFlag(ItemIsMovable);
    setFlag(ItemSendsGeometryChanges);
    setCacheMode(DeviceCoordinateCache);
    setAcceptDrops(true);
    setZValue(2);

    /* Pour afficher la tooltips */
    setToolTip( etat->getNom() + "( " + etat->getContinent()->nom + " )" );

    this->etat = etat;
    dragOver = false;
    QGraphicsItem::setPos(etat->pos());

    connect(etat, SIGNAL(updateGraphics()), this, SLOT(updateGraphics()));
}

void EtatGraphics::updateGraphics()
{
    update(boundingRect());
}

void EtatGraphics::setMove(bool b){
    setFlag(ItemIsMovable, b);
}

bool EtatGraphics::getMove(){
    return flags().testFlag(ItemIsMovable);
}

void EtatGraphics::setPos(int x, int y)
{
    etat->setPos(x, y);
    QGraphicsItem::setPos(x, y);
}

void EtatGraphics::setPos(QPointF point)
{
    etat->setPos(point.x(), point.y());
    QGraphicsItem::setPos(point);
}

QPointF EtatGraphics::getPos()
{
    return QGraphicsItem::pos();
}

void EtatGraphics::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *)
{
    Qt::GlobalColor color, colorDark;
    if ( etat->getJoueur() == NULL ){
        color = Qt::gray;
        colorDark = Qt::darkGray;
    }else{
        color = etat->getJoueur()->getCouleur();
        colorDark = etat->getJoueur()->getCouleurDark();
    }

    painter->setPen(Qt::NoPen);
    painter->setBrush(Qt::darkGray);
    painter->drawEllipse(-3, -3, 10, 10);

    QRadialGradient gradient(-3, -3, 10);
    if (option->state & QStyle::State_Sunken) {
        gradient.setCenter(3, 3);
        gradient.setFocalPoint(3, 3);
        gradient.setColorAt(1, QColor(color).light(120));
        gradient.setColorAt(0, QColor(colorDark).light(120));
    } else {
        gradient.setColorAt(0, color);
        gradient.setColorAt(1, colorDark);
    }
    painter->setBrush(gradient);
    painter->setPen(QPen(Qt::black, 0));
    painter->drawEllipse(-5, -5, 10, 10);
}

// resize??
QRectF EtatGraphics::boundingRect() const
{
    qreal adjust = 2;
    return QRectF(-10 - adjust, -10 - adjust,
                  23 + adjust, 23 + adjust);
}

QPainterPath EtatGraphics::shape() const
{
    QPainterPath path;
    path.addEllipse(-5, -5, 10, 10);
    return path;
}

QVariant EtatGraphics::itemChange(GraphicsItemChange change, const QVariant &value)
{
    switch (change) {
    case ItemPositionHasChanged:
        etat->setPos(pos().x(), pos().y());
        break;
    default:
        break;
    };

    return QGraphicsItem::itemChange(change, value);
}

void EtatGraphics::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    Joueur *j = etat->getPlateau()->getMoi();

     if (j == NULL) return;

      if (etat->getPlateau()->getJoueur_en_cours() == j->getId())
      {
          /*if ( etat->getPlateau()->getplacement_Initial() || etat->getPlateau()->getplacement_renforts() )
          {

              Verifie que l'état appartient au joueur
              if ( j == NULL || etat->getJoueur() != j )
                  return;

              if (event->button() == Qt::LeftButton){

                  if ( j->getNbPionRestant() < 1 )
                      return;

                  Pion *pion = new Pion();
                  etat->addPion(pion);

              }else if (event->button() == Qt::RightButton){
                  if ( !etat->pions().isEmpty() ){
                      etat->removeLastPion();
                  }
              }
          }*/

          if ( etat->getPlateau()->getplacement_Initial() )
          {
              if ( etat->getJoueur()->getId() == j->getId() && event->button() == Qt::LeftButton)
              {
                  if ( j->getNbPionRestant() > 0 )
                  {
                      etat->getPlateau()->placementInitial(etat);
                  }
              }
          }


          if ( etat->getPlateau()->getplacement_renforts() )
          {
              if ( etat->getJoueur()->getId() == j->getId() && event->button() == Qt::LeftButton)
              {
                  if ( j->getNbPionRestant() > 0 )
                  {
                      this->etat->getPlateau()->placementRenfort(etat);
                      //etat->getPlateau()->placementRenfort(etat);
                  }
              }
          }

          if ( etat->getPlateau()->getattaques() )
          {
              Etat *etatatt;
              Etat *etatcbl;

              if( etat->getJoueur()->getId() == j->getId() && etat->pions().count()>0 ){
                  etat->getPlateau()->setEtat_attaquant(etat->getId());
                  LOG1(ONOTICE, "Pays Attaquant : %1",etat->getNom());
              }

              if( etat->getJoueur() != j ){
                  etat->getPlateau()->setEtat_cible(etat->getId());
                  LOG1(ONOTICE, "Pays Cible : %1",etat->getNom());
              }

              if((etat->getPlateau()->getEtat_attaquant()!=-1)&&(etat->getPlateau()->getEtat_cible()!=-1)){
                  etatatt = etat->getPlateau()->etats()[etat->getPlateau()->getEtat_attaquant()];
                  etatcbl = etat->getPlateau()->etats()[etat->getPlateau()->getEtat_cible()];

                  if( etatatt->canMove(etatcbl) ){
                      LOG2(ONOTICE, "Les troupes stationnées en %1 entrent en %2",etatatt->getNom(),etatcbl->getNom());
                      etat->getPlateau()->attaque(etatatt->getId(),etatcbl->getId());
                  }
                  else LOG2(ONOTICE, "Impossible d'attaquer %2 depuis %1",etatatt->getNom(),etatcbl->getNom());

                  etat->getPlateau()->setEtat_attaquant(-1);
                  etat->getPlateau()->setEtat_cible(-1);
              }
          }
      }

}

void EtatGraphics::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    update();
    QGraphicsItem::mouseReleaseEvent(event);
}

void EtatGraphics::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
{

    update();
    QGraphicsItem::mouseDoubleClickEvent(event);

}

void EtatGraphics::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
{
    if (etat->getPlateau()->getJoueur_en_cours() == etat->getPlateau()->getMoi()->getId())
    {
        if (etat->getPlateau()->getdeplacement_troupes())
        {
            if (event->mimeData()->hasText()) {
                if ( event->mimeData()->hasText()){
                    QByteArray b = event->mimeData()->data("text/plain");
        
                    Joueur *j = etat->getPlateau()->getMoi();
        
        
                    int idEtat = b.toInt();
                    Etat *etatsrc = etat->getPlateau()->etats()[idEtat];
        
        
                    if ( j == NULL || etatsrc == NULL ){
        
                    /* Verifie que l'état src appartient au joueur */
                    }else if ( etatsrc->getJoueur() != j ){
        
                    /* Verifie que l'état dst appartient au joueur */
                    }else if (etat->getJoueur() != j ){
        
                    /* Verifie que les 2 états possède une frontiere */
                    }else if ( etat->canMove(etatsrc)){
                        event->setAccepted(true);
                        dragOver = true;
                        update();
                        return;
                    }
                }
            }
        
            event->setAccepted(false);
        }
    }

}

void EtatGraphics::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
{
    if (etat->getPlateau()->getJoueur_en_cours() == etat->getPlateau()->getMoi()->getId())
    {
        if (etat->getPlateau()->getdeplacement_troupes())
        {
            Q_UNUSED(event);
            dragOver = false;
            update();
        }
    }
}

void EtatGraphics::dropEvent(QGraphicsSceneDragDropEvent *event)
{
    if (etat->getPlateau()->getJoueur_en_cours() == etat->getPlateau()->getMoi()->getId())
    {
        if (etat->getPlateau()->getdeplacement_troupes())
        {
            dragOver = false;
            if (event->mimeData()->hasText()){
                QByteArray b = event->mimeData()->data("text/plain");
        
                int idEtat = b.toInt();
                Etat *etatsrc = etat->getPlateau()->etats()[idEtat];
                if (etatsrc != NULL){
                    /* Récupère le dernier pion de l'état src */
                    Pion *p = etatsrc->pions().last();
                    /* Enleve le pion de l'état src */
                    etatsrc->removeLastPion();
                    /* Ajoute le pion à l'état dst */
                    etat->addPion(p);
                }
        
            }
        
            update();
        }
    }
}

